/** 
    ____                            
   / __ )_________ __   _____  _____
  / __  / ___/ __ `/ | / / _ \/ ___/
 / /_/ / /  / /_/ /| |/ /  __/ /    
/_____/_/   \__,_/ |___/\___/_/     
* @Title: EncryptionSyncStringCacheLoader.java 
* @Package soft.ay.qram 
* @Description: AES加密版本
* @author vsuns 
* @date 2019年7月7日 
* @version V1.0 
*/
package soft.ay.qram;

import java.security.Key;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.TimeUnit;

import soft.ay.qram.helpers.AESUtil;

/**  
*  
*/
public class AesSyncStringCacheLoader extends AbstractCacheLoader
{
    // 属性部分
    private final String AES_KEY = "61651d822197bc1664dbfe78837dc216fa4310f2";
    private Key aesKey = null;

    // ------------------分割线------------------
    // 方法部分
    public AesSyncStringCacheLoader()
    {
        try
        {
            this.aesKey = AESUtil.getKey(AES_KEY);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    @Override
    public void addToCache(String key, String value)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方
        byte[] encryptData = null;
        try
        {
            encryptData = AESUtil.encrypt(value.getBytes(), this.aesKey);
            value = AESUtil.byteToHexString(encryptData);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        // 逻辑处理结束的地方
        encryptData = null;
        // 局部变量销毁的地方
        super.addToCache(key, value);
    }
    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @param value
     * 
     * @param expire
     * 
     * @see soft.ay.qram.CacheLoader#addToCache(java.lang.String,
     * java.lang.String, java.lang.Long)
     */

    @Override
    public void addToCache(String key, String value, TimeUnit unit, Long expire)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方
        byte[] encryptData = null;
        try
        {
            encryptData = AESUtil.encrypt(value.getBytes(), this.aesKey);
            value = AESUtil.byteToHexString(encryptData);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        // 逻辑处理结束的地方
        encryptData = null;
        // 局部变量销毁的地方
        super.addToCache(key, value, unit, expire);
    }

    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @return
     * 
     * @see soft.ay.qram.CacheLoader#getFromCache(java.lang.String)
     */

    @Override
    public String getFromCache(String key)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方
        String fromCache = super.getFromCache(key);
        byte[] hexStringtoByte = AESUtil.hexStringtoByte(fromCache);
        byte[] decryptData = null;
        String value = null;
        // 逻辑处理开始的地方
        try
        {
            decryptData = AESUtil.decrypt(hexStringtoByte, this.aesKey);
            value = new String(decryptData);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        // 逻辑处理结束的地方

        // 局部变量销毁的地方
        hexStringtoByte = null;
        return value;
    }

    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @return
     * 
     * @see soft.ay.qram.ICacheLoader#getFromCacheByMatchKey(java.lang.String)
     */

    @Override
    public Map<String, String> getFromCacheByMatchKey(String key)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方
        Map<String, String> fromCacheByMatchKey = super.getFromCacheByMatchKey(key);
        Map<String, String> decryptCacheByMatchKey = new HashMap<>(fromCacheByMatchKey.size());
        // 逻辑处理开始的地方
        if(fromCacheByMatchKey!=null && fromCacheByMatchKey.size()>0){
            byte[] hexStringtoByte = null;
            byte[] decryptData = null;
            String value = null;
            for (Entry<String, String> eachEntry : fromCacheByMatchKey.entrySet())
            {
                try
                {
                    hexStringtoByte = AESUtil.hexStringtoByte(eachEntry.getValue());
                    decryptData = AESUtil.decrypt(hexStringtoByte, this.aesKey);
                    value = new String(decryptData);
                    decryptCacheByMatchKey.put(eachEntry.getKey(), value);
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                    continue;
                }
                // 逻辑处理结束的地方
                
            }
            // 局部变量销毁的地方
            hexStringtoByte = null;
        }
        // 局部变量销毁的地方
        fromCacheByMatchKey = null;
        return decryptCacheByMatchKey;
    }

}
